﻿using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.Reflection;

namespace HslCommunication.Core.Net
{
	/// <summary>
	/// Udp报文协议的内容传送
	/// </summary>
	// Token: 0x02000140 RID: 320
	public class NetworkUdpDeviceBase : NetworkUdpBase, IReadWriteNet
	{
		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDoubleBase.ByteTransform" />
		// Token: 0x1700057F RID: 1407
		// (get) Token: 0x06001BB4 RID: 7092 RVA: 0x0008999C File Offset: 0x00087B9C
		// (set) Token: 0x06001BB5 RID: 7093 RVA: 0x000899B4 File Offset: 0x00087BB4
		public IByteTransform ByteTransform
		{
			get
			{
				return this.byteTransform;
			}
			set
			{
				this.byteTransform = value;
			}
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDeviceBase.WordLength" />
		// Token: 0x17000580 RID: 1408
		// (get) Token: 0x06001BB6 RID: 7094 RVA: 0x000899BE File Offset: 0x00087BBE
		// (set) Token: 0x06001BB7 RID: 7095 RVA: 0x000899C6 File Offset: 0x00087BC6
		protected ushort WordLength { get; set; } = 1;

		/// <inheritdoc />
		// Token: 0x06001BB8 RID: 7096 RVA: 0x000899CF File Offset: 0x00087BCF
		public override string ToString()
		{
			return string.Format("NetworkUdpDeviceBase<{0}>[{1}:{2}]", this.ByteTransform.GetType(), this.IpAddress, this.Port);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read(System.String,System.UInt16)" />
		// Token: 0x06001BB9 RID: 7097 RVA: 0x0000ABFE File Offset: 0x00008DFE
		[HslMqttApi("ReadByteArray", "")]
		public virtual OperateResult<byte[]> Read(string address, ushort length)
		{
			return new OperateResult<byte[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Byte[])" />
		// Token: 0x06001BBA RID: 7098 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteByteArray", "")]
		public virtual OperateResult Write(string address, byte[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String,System.UInt16)" />
		// Token: 0x06001BBB RID: 7099 RVA: 0x0000AC20 File Offset: 0x00008E20
		[HslMqttApi("ReadBoolArray", "")]
		public virtual OperateResult<bool[]> ReadBool(string address, ushort length)
		{
			return new OperateResult<bool[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String)" />
		// Token: 0x06001BBC RID: 7100 RVA: 0x000899F7 File Offset: 0x00087BF7
		[HslMqttApi("ReadBool", "")]
		public virtual OperateResult<bool> ReadBool(string address)
		{
			return ByteTransformHelper.GetResultFromArray<bool>(this.ReadBool(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean[])" />
		// Token: 0x06001BBD RID: 7101 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteBoolArray", "")]
		public virtual OperateResult Write(string address, bool[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean)" />
		// Token: 0x06001BBE RID: 7102 RVA: 0x00089A06 File Offset: 0x00087C06
		[HslMqttApi("WriteBool", "")]
		public virtual OperateResult Write(string address, bool value)
		{
			return this.Write(address, new bool[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadCustomer``1(System.String)" />
		// Token: 0x06001BBF RID: 7103 RVA: 0x00089A1C File Offset: 0x00087C1C
		public OperateResult<T> ReadCustomer<T>(string address) where T : IDataTransfer, new()
		{
			OperateResult<T> operateResult = new OperateResult<T>();
			T content = Activator.CreateInstance<T>();
			OperateResult<byte[]> operateResult2 = this.Read(address, content.ReadCount);
			bool isSuccess = operateResult2.IsSuccess;
			if (isSuccess)
			{
				content.ParseSource(operateResult2.Content);
				operateResult.Content = content;
				operateResult.IsSuccess = true;
			}
			else
			{
				operateResult.ErrorCode = operateResult2.ErrorCode;
				operateResult.Message = operateResult2.Message;
			}
			return operateResult;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomer``1(System.String,``0)" />
		// Token: 0x06001BC0 RID: 7104 RVA: 0x00089AA0 File Offset: 0x00087CA0
		public OperateResult WriteCustomer<T>(string address, T data) where T : IDataTransfer, new()
		{
			return this.Write(address, data.ToSource());
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read``1" />
		// Token: 0x06001BC1 RID: 7105 RVA: 0x00089AB6 File Offset: 0x00087CB6
		public virtual OperateResult<T> Read<T>() where T : class, new()
		{
			return HslReflectionHelper.Read<T>(this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write``1(``0)" />
		// Token: 0x06001BC2 RID: 7106 RVA: 0x00089ABE File Offset: 0x00087CBE
		public virtual OperateResult Write<T>(T data) where T : class, new()
		{
			return HslReflectionHelper.Write<T>(data, this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String)" />
		// Token: 0x06001BC3 RID: 7107 RVA: 0x00089AC7 File Offset: 0x00087CC7
		[HslMqttApi("ReadInt16", "")]
		public OperateResult<short> ReadInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<short>(this.ReadInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String,System.UInt16)" />
		// Token: 0x06001BC4 RID: 7108 RVA: 0x00089AD8 File Offset: 0x00087CD8
		[HslMqttApi("ReadInt16Array", "")]
		public virtual OperateResult<short[]> ReadInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String)" />
		// Token: 0x06001BC5 RID: 7109 RVA: 0x00089B1F File Offset: 0x00087D1F
		[HslMqttApi("ReadUInt16", "")]
		public OperateResult<ushort> ReadUInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ushort>(this.ReadUInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String,System.UInt16)" />
		// Token: 0x06001BC6 RID: 7110 RVA: 0x00089B30 File Offset: 0x00087D30
		[HslMqttApi("ReadUInt16Array", "")]
		public virtual OperateResult<ushort[]> ReadUInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransUInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String)" />
		// Token: 0x06001BC7 RID: 7111 RVA: 0x00089B77 File Offset: 0x00087D77
		[HslMqttApi("ReadInt32", "")]
		public OperateResult<int> ReadInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<int>(this.ReadInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String,System.UInt16)" />
		// Token: 0x06001BC8 RID: 7112 RVA: 0x00089B88 File Offset: 0x00087D88
		[HslMqttApi("ReadInt32Array", "")]
		public virtual OperateResult<int[]> ReadInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String)" />
		// Token: 0x06001BC9 RID: 7113 RVA: 0x00089BD1 File Offset: 0x00087DD1
		[HslMqttApi("ReadUInt32", "")]
		public OperateResult<uint> ReadUInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<uint>(this.ReadUInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String,System.UInt16)" />
		// Token: 0x06001BCA RID: 7114 RVA: 0x00089BE0 File Offset: 0x00087DE0
		[HslMqttApi("ReadUInt32Array", "")]
		public virtual OperateResult<uint[]> ReadUInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransUInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String)" />
		// Token: 0x06001BCB RID: 7115 RVA: 0x00089C29 File Offset: 0x00087E29
		[HslMqttApi("ReadFloat", "")]
		public OperateResult<float> ReadFloat(string address)
		{
			return ByteTransformHelper.GetResultFromArray<float>(this.ReadFloat(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String,System.UInt16)" />
		// Token: 0x06001BCC RID: 7116 RVA: 0x00089C38 File Offset: 0x00087E38
		[HslMqttApi("ReadFloatArray", "")]
		public virtual OperateResult<float[]> ReadFloat(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransSingle(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String)" />
		// Token: 0x06001BCD RID: 7117 RVA: 0x00089C81 File Offset: 0x00087E81
		[HslMqttApi("ReadInt64", "")]
		public OperateResult<long> ReadInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<long>(this.ReadInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String,System.UInt16)" />
		// Token: 0x06001BCE RID: 7118 RVA: 0x00089C90 File Offset: 0x00087E90
		[HslMqttApi("ReadInt64Array", "")]
		public virtual OperateResult<long[]> ReadInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String)" />
		// Token: 0x06001BCF RID: 7119 RVA: 0x00089CD9 File Offset: 0x00087ED9
		[HslMqttApi("ReadUInt64", "")]
		public OperateResult<ulong> ReadUInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ulong>(this.ReadUInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String,System.UInt16)" />
		// Token: 0x06001BD0 RID: 7120 RVA: 0x00089CE8 File Offset: 0x00087EE8
		[HslMqttApi("ReadUInt64Array", "")]
		public virtual OperateResult<ulong[]> ReadUInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransUInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String)" />
		// Token: 0x06001BD1 RID: 7121 RVA: 0x00089D31 File Offset: 0x00087F31
		[HslMqttApi("ReadDouble", "")]
		public OperateResult<double> ReadDouble(string address)
		{
			return ByteTransformHelper.GetResultFromArray<double>(this.ReadDouble(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String,System.UInt16)" />
		// Token: 0x06001BD2 RID: 7122 RVA: 0x00089D40 File Offset: 0x00087F40
		[HslMqttApi("ReadDoubleArray", "")]
		public virtual OperateResult<double[]> ReadDouble(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransDouble(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16)" />
		// Token: 0x06001BD3 RID: 7123 RVA: 0x00089D89 File Offset: 0x00087F89
		[HslMqttApi("ReadString", "")]
		public OperateResult<string> ReadString(string address, ushort length)
		{
			return this.ReadString(address, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001BD4 RID: 7124 RVA: 0x00089D98 File Offset: 0x00087F98
		public virtual OperateResult<string> ReadString(string address, ushort length, Encoding encoding)
		{
			return ByteTransformHelper.GetResultFromBytes<string>(this.Read(address, length), (byte[] m) => this.ByteTransform.TransString(m, 0, m.Length, encoding));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16[])" />
		// Token: 0x06001BD5 RID: 7125 RVA: 0x00089DD2 File Offset: 0x00087FD2
		[HslMqttApi("WriteInt16Array", "")]
		public virtual OperateResult Write(string address, short[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16)" />
		// Token: 0x06001BD6 RID: 7126 RVA: 0x00089DE7 File Offset: 0x00087FE7
		[HslMqttApi("WriteInt16", "")]
		public virtual OperateResult Write(string address, short value)
		{
			return this.Write(address, new short[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16[])" />
		// Token: 0x06001BD7 RID: 7127 RVA: 0x00089DFA File Offset: 0x00087FFA
		[HslMqttApi("WriteUInt16Array", "")]
		public virtual OperateResult Write(string address, ushort[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16)" />
		// Token: 0x06001BD8 RID: 7128 RVA: 0x00089E0F File Offset: 0x0008800F
		[HslMqttApi("WriteUInt16", "")]
		public virtual OperateResult Write(string address, ushort value)
		{
			return this.Write(address, new ushort[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32[])" />
		// Token: 0x06001BD9 RID: 7129 RVA: 0x00089E22 File Offset: 0x00088022
		[HslMqttApi("WriteInt32Array", "")]
		public virtual OperateResult Write(string address, int[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32)" />
		// Token: 0x06001BDA RID: 7130 RVA: 0x00089E37 File Offset: 0x00088037
		[HslMqttApi("WriteInt32", "")]
		public OperateResult Write(string address, int value)
		{
			return this.Write(address, new int[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32[])" />
		// Token: 0x06001BDB RID: 7131 RVA: 0x00089E4A File Offset: 0x0008804A
		[HslMqttApi("WriteUInt32Array", "")]
		public virtual OperateResult Write(string address, uint[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32)" />
		// Token: 0x06001BDC RID: 7132 RVA: 0x00089E5F File Offset: 0x0008805F
		[HslMqttApi("WriteUInt32", "")]
		public OperateResult Write(string address, uint value)
		{
			return this.Write(address, new uint[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single[])" />
		// Token: 0x06001BDD RID: 7133 RVA: 0x00089E72 File Offset: 0x00088072
		[HslMqttApi("WriteFloatArray", "")]
		public virtual OperateResult Write(string address, float[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single)" />
		// Token: 0x06001BDE RID: 7134 RVA: 0x00089E87 File Offset: 0x00088087
		[HslMqttApi("WriteFloat", "")]
		public OperateResult Write(string address, float value)
		{
			return this.Write(address, new float[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64[])" />
		// Token: 0x06001BDF RID: 7135 RVA: 0x00089E9A File Offset: 0x0008809A
		[HslMqttApi("WriteInt64Array", "")]
		public virtual OperateResult Write(string address, long[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64)" />
		// Token: 0x06001BE0 RID: 7136 RVA: 0x00089EAF File Offset: 0x000880AF
		[HslMqttApi("WriteInt64", "")]
		public OperateResult Write(string address, long value)
		{
			return this.Write(address, new long[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64[])" />
		// Token: 0x06001BE1 RID: 7137 RVA: 0x00089EC2 File Offset: 0x000880C2
		[HslMqttApi("WriteUInt64Array", "")]
		public virtual OperateResult Write(string address, ulong[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64)" />
		// Token: 0x06001BE2 RID: 7138 RVA: 0x00089ED7 File Offset: 0x000880D7
		[HslMqttApi("WriteUInt64", "")]
		public OperateResult Write(string address, ulong value)
		{
			return this.Write(address, new ulong[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double[])" />
		// Token: 0x06001BE3 RID: 7139 RVA: 0x00089EEA File Offset: 0x000880EA
		[HslMqttApi("WriteDoubleArray", "")]
		public virtual OperateResult Write(string address, double[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double)" />
		// Token: 0x06001BE4 RID: 7140 RVA: 0x00089EFF File Offset: 0x000880FF
		[HslMqttApi("WriteDouble", "")]
		public OperateResult Write(string address, double value)
		{
			return this.Write(address, new double[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String)" />
		// Token: 0x06001BE5 RID: 7141 RVA: 0x00089F12 File Offset: 0x00088112
		[HslMqttApi("WriteString", "")]
		public virtual OperateResult Write(string address, string value)
		{
			return this.Write(address, value, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32)" />
		// Token: 0x06001BE6 RID: 7142 RVA: 0x00089F21 File Offset: 0x00088121
		public virtual OperateResult Write(string address, string value, int length)
		{
			return this.Write(address, value, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001BE7 RID: 7143 RVA: 0x00089F34 File Offset: 0x00088134
		public virtual OperateResult Write(string address, string value, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001BE8 RID: 7144 RVA: 0x00089F70 File Offset: 0x00088170
		public virtual OperateResult Write(string address, string value, int length, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			array = SoftBasic.ArrayExpandToLength<byte>(array, length);
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001BE9 RID: 7145 RVA: 0x0000B1ED File Offset: 0x000093ED
		[HslMqttApi("WaitBool", "")]
		public OperateResult<TimeSpan> Wait(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001BEA RID: 7146 RVA: 0x0000B1FA File Offset: 0x000093FA
		[HslMqttApi("WaitInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001BEB RID: 7147 RVA: 0x0000B207 File Offset: 0x00009407
		[HslMqttApi("WaitUInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001BEC RID: 7148 RVA: 0x0000B214 File Offset: 0x00009414
		[HslMqttApi("WaitInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001BED RID: 7149 RVA: 0x0000B221 File Offset: 0x00009421
		[HslMqttApi("WaitUInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001BEE RID: 7150 RVA: 0x0000B22E File Offset: 0x0000942E
		[HslMqttApi("WaitInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001BEF RID: 7151 RVA: 0x0000B23B File Offset: 0x0000943B
		[HslMqttApi("WaitUInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001BF0 RID: 7152 RVA: 0x00089FB8 File Offset: 0x000881B8
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__65 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__65();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__65>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001BF1 RID: 7153 RVA: 0x0008A01C File Offset: 0x0008821C
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__66 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__66();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__66>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001BF2 RID: 7154 RVA: 0x0008A080 File Offset: 0x00088280
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__67 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__67();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__67>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001BF3 RID: 7155 RVA: 0x0008A0E4 File Offset: 0x000882E4
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__68 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__68();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__68>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001BF4 RID: 7156 RVA: 0x0008A148 File Offset: 0x00088348
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__69 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__69();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__69>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001BF5 RID: 7157 RVA: 0x0008A1AC File Offset: 0x000883AC
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__70 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__70();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__70>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001BF6 RID: 7158 RVA: 0x0008A210 File Offset: 0x00088410
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkUdpDeviceBase.<WaitAsync>d__71 <WaitAsync>d__ = new NetworkUdpDeviceBase.<WaitAsync>d__71();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WaitAsync>d__71>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync(System.String,System.UInt16)" />
		// Token: 0x06001BF7 RID: 7159 RVA: 0x0008A274 File Offset: 0x00088474
		[DebuggerStepThrough]
		public virtual Task<OperateResult<byte[]>> ReadAsync(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadAsync>d__72 <ReadAsync>d__ = new NetworkUdpDeviceBase.<ReadAsync>d__72();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.address = address;
			<ReadAsync>d__.length = length;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadAsync>d__72>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Byte[])" />
		// Token: 0x06001BF8 RID: 7160 RVA: 0x0008A2C8 File Offset: 0x000884C8
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, byte[] value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__73 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__73();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__73>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String,System.UInt16)" />
		// Token: 0x06001BF9 RID: 7161 RVA: 0x0008A31C File Offset: 0x0008851C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool[]>> ReadBoolAsync(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadBoolAsync>d__74 <ReadBoolAsync>d__ = new NetworkUdpDeviceBase.<ReadBoolAsync>d__74();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool[]>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.length = length;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadBoolAsync>d__74>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String)" />
		// Token: 0x06001BFA RID: 7162 RVA: 0x0008A370 File Offset: 0x00088570
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool>> ReadBoolAsync(string address)
		{
			NetworkUdpDeviceBase.<ReadBoolAsync>d__75 <ReadBoolAsync>d__ = new NetworkUdpDeviceBase.<ReadBoolAsync>d__75();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadBoolAsync>d__75>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean[])" />
		// Token: 0x06001BFB RID: 7163 RVA: 0x0008A3BC File Offset: 0x000885BC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool[] value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__76 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__76();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__76>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean)" />
		// Token: 0x06001BFC RID: 7164 RVA: 0x0008A410 File Offset: 0x00088610
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__77 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__77();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__77>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001BFD RID: 7165 RVA: 0x0008A464 File Offset: 0x00088664
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadCustomerAsync<T>(string address) where T : IDataTransfer, new()
		{
			NetworkUdpDeviceBase.<ReadCustomerAsync>d__78<T> <ReadCustomerAsync>d__ = new NetworkUdpDeviceBase.<ReadCustomerAsync>d__78<T>();
			<ReadCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadCustomerAsync>d__.<>4__this = this;
			<ReadCustomerAsync>d__.address = address;
			<ReadCustomerAsync>d__.<>1__state = -1;
			<ReadCustomerAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadCustomerAsync>d__78<T>>(ref <ReadCustomerAsync>d__);
			return <ReadCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001BFE RID: 7166 RVA: 0x0008A4B0 File Offset: 0x000886B0
		[DebuggerStepThrough]
		public Task<OperateResult> WriteCustomerAsync<T>(string address, T data) where T : IDataTransfer, new()
		{
			NetworkUdpDeviceBase.<WriteCustomerAsync>d__79<T> <WriteCustomerAsync>d__ = new NetworkUdpDeviceBase.<WriteCustomerAsync>d__79<T>();
			<WriteCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteCustomerAsync>d__.<>4__this = this;
			<WriteCustomerAsync>d__.address = address;
			<WriteCustomerAsync>d__.data = data;
			<WriteCustomerAsync>d__.<>1__state = -1;
			<WriteCustomerAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteCustomerAsync>d__79<T>>(ref <WriteCustomerAsync>d__);
			return <WriteCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync``1" />
		// Token: 0x06001BFF RID: 7167 RVA: 0x0008A504 File Offset: 0x00088704
		[DebuggerStepThrough]
		public virtual Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			NetworkUdpDeviceBase.<ReadAsync>d__80<T> <ReadAsync>d__ = new NetworkUdpDeviceBase.<ReadAsync>d__80<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadAsync>d__80<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync``1(``0)" />
		// Token: 0x06001C00 RID: 7168 RVA: 0x0008A548 File Offset: 0x00088748
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			NetworkUdpDeviceBase.<WriteAsync>d__81<T> <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__81<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__81<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String)" />
		// Token: 0x06001C01 RID: 7169 RVA: 0x0008A594 File Offset: 0x00088794
		[DebuggerStepThrough]
		public Task<OperateResult<short>> ReadInt16Async(string address)
		{
			NetworkUdpDeviceBase.<ReadInt16Async>d__82 <ReadInt16Async>d__ = new NetworkUdpDeviceBase.<ReadInt16Async>d__82();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt16Async>d__82>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001C02 RID: 7170 RVA: 0x0008A5E0 File Offset: 0x000887E0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<short[]>> ReadInt16Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadInt16Async>d__83 <ReadInt16Async>d__ = new NetworkUdpDeviceBase.<ReadInt16Async>d__83();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short[]>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.length = length;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt16Async>d__83>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String)" />
		// Token: 0x06001C03 RID: 7171 RVA: 0x0008A634 File Offset: 0x00088834
		[DebuggerStepThrough]
		public Task<OperateResult<ushort>> ReadUInt16Async(string address)
		{
			NetworkUdpDeviceBase.<ReadUInt16Async>d__84 <ReadUInt16Async>d__ = new NetworkUdpDeviceBase.<ReadUInt16Async>d__84();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt16Async>d__84>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001C04 RID: 7172 RVA: 0x0008A680 File Offset: 0x00088880
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ushort[]>> ReadUInt16Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadUInt16Async>d__85 <ReadUInt16Async>d__ = new NetworkUdpDeviceBase.<ReadUInt16Async>d__85();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort[]>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.length = length;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt16Async>d__85>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String)" />
		// Token: 0x06001C05 RID: 7173 RVA: 0x0008A6D4 File Offset: 0x000888D4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadInt32Async(string address)
		{
			NetworkUdpDeviceBase.<ReadInt32Async>d__86 <ReadInt32Async>d__ = new NetworkUdpDeviceBase.<ReadInt32Async>d__86();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt32Async>d__86>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001C06 RID: 7174 RVA: 0x0008A720 File Offset: 0x00088920
		[DebuggerStepThrough]
		public virtual Task<OperateResult<int[]>> ReadInt32Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadInt32Async>d__87 <ReadInt32Async>d__ = new NetworkUdpDeviceBase.<ReadInt32Async>d__87();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int[]>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.length = length;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt32Async>d__87>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String)" />
		// Token: 0x06001C07 RID: 7175 RVA: 0x0008A774 File Offset: 0x00088974
		[DebuggerStepThrough]
		public Task<OperateResult<uint>> ReadUInt32Async(string address)
		{
			NetworkUdpDeviceBase.<ReadUInt32Async>d__88 <ReadUInt32Async>d__ = new NetworkUdpDeviceBase.<ReadUInt32Async>d__88();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt32Async>d__88>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001C08 RID: 7176 RVA: 0x0008A7C0 File Offset: 0x000889C0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<uint[]>> ReadUInt32Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadUInt32Async>d__89 <ReadUInt32Async>d__ = new NetworkUdpDeviceBase.<ReadUInt32Async>d__89();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint[]>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.length = length;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt32Async>d__89>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String)" />
		// Token: 0x06001C09 RID: 7177 RVA: 0x0008A814 File Offset: 0x00088A14
		[DebuggerStepThrough]
		public Task<OperateResult<float>> ReadFloatAsync(string address)
		{
			NetworkUdpDeviceBase.<ReadFloatAsync>d__90 <ReadFloatAsync>d__ = new NetworkUdpDeviceBase.<ReadFloatAsync>d__90();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadFloatAsync>d__90>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String,System.UInt16)" />
		// Token: 0x06001C0A RID: 7178 RVA: 0x0008A860 File Offset: 0x00088A60
		[DebuggerStepThrough]
		public virtual Task<OperateResult<float[]>> ReadFloatAsync(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadFloatAsync>d__91 <ReadFloatAsync>d__ = new NetworkUdpDeviceBase.<ReadFloatAsync>d__91();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float[]>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.length = length;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadFloatAsync>d__91>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String)" />
		// Token: 0x06001C0B RID: 7179 RVA: 0x0008A8B4 File Offset: 0x00088AB4
		[DebuggerStepThrough]
		public Task<OperateResult<long>> ReadInt64Async(string address)
		{
			NetworkUdpDeviceBase.<ReadInt64Async>d__92 <ReadInt64Async>d__ = new NetworkUdpDeviceBase.<ReadInt64Async>d__92();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt64Async>d__92>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001C0C RID: 7180 RVA: 0x0008A900 File Offset: 0x00088B00
		[DebuggerStepThrough]
		public virtual Task<OperateResult<long[]>> ReadInt64Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadInt64Async>d__93 <ReadInt64Async>d__ = new NetworkUdpDeviceBase.<ReadInt64Async>d__93();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long[]>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.length = length;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadInt64Async>d__93>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String)" />
		// Token: 0x06001C0D RID: 7181 RVA: 0x0008A954 File Offset: 0x00088B54
		[DebuggerStepThrough]
		public Task<OperateResult<ulong>> ReadUInt64Async(string address)
		{
			NetworkUdpDeviceBase.<ReadUInt64Async>d__94 <ReadUInt64Async>d__ = new NetworkUdpDeviceBase.<ReadUInt64Async>d__94();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt64Async>d__94>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001C0E RID: 7182 RVA: 0x0008A9A0 File Offset: 0x00088BA0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ulong[]>> ReadUInt64Async(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadUInt64Async>d__95 <ReadUInt64Async>d__ = new NetworkUdpDeviceBase.<ReadUInt64Async>d__95();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong[]>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.length = length;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadUInt64Async>d__95>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String)" />
		// Token: 0x06001C0F RID: 7183 RVA: 0x0008A9F4 File Offset: 0x00088BF4
		[DebuggerStepThrough]
		public Task<OperateResult<double>> ReadDoubleAsync(string address)
		{
			NetworkUdpDeviceBase.<ReadDoubleAsync>d__96 <ReadDoubleAsync>d__ = new NetworkUdpDeviceBase.<ReadDoubleAsync>d__96();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadDoubleAsync>d__96>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String,System.UInt16)" />
		// Token: 0x06001C10 RID: 7184 RVA: 0x0008AA40 File Offset: 0x00088C40
		[DebuggerStepThrough]
		public virtual Task<OperateResult<double[]>> ReadDoubleAsync(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadDoubleAsync>d__97 <ReadDoubleAsync>d__ = new NetworkUdpDeviceBase.<ReadDoubleAsync>d__97();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double[]>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.length = length;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadDoubleAsync>d__97>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16)" />
		// Token: 0x06001C11 RID: 7185 RVA: 0x0008AA94 File Offset: 0x00088C94
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadStringAsync(string address, ushort length)
		{
			NetworkUdpDeviceBase.<ReadStringAsync>d__98 <ReadStringAsync>d__ = new NetworkUdpDeviceBase.<ReadStringAsync>d__98();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadStringAsync>d__98>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001C12 RID: 7186 RVA: 0x0008AAE8 File Offset: 0x00088CE8
		[DebuggerStepThrough]
		public virtual Task<OperateResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding)
		{
			NetworkUdpDeviceBase.<ReadStringAsync>d__99 <ReadStringAsync>d__ = new NetworkUdpDeviceBase.<ReadStringAsync>d__99();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.encoding = encoding;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<ReadStringAsync>d__99>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16[])" />
		// Token: 0x06001C13 RID: 7187 RVA: 0x0008AB44 File Offset: 0x00088D44
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__100 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__100();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__100>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16)" />
		// Token: 0x06001C14 RID: 7188 RVA: 0x0008AB98 File Offset: 0x00088D98
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__101 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__101();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__101>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16[])" />
		// Token: 0x06001C15 RID: 7189 RVA: 0x0008ABEC File Offset: 0x00088DEC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__102 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__102();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__102>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16)" />
		// Token: 0x06001C16 RID: 7190 RVA: 0x0008AC40 File Offset: 0x00088E40
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__103 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__103();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__103>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32[])" />
		// Token: 0x06001C17 RID: 7191 RVA: 0x0008AC94 File Offset: 0x00088E94
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, int[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__104 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__104();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__104>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32)" />
		// Token: 0x06001C18 RID: 7192 RVA: 0x0008ACE8 File Offset: 0x00088EE8
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, int value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__105 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__105();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__105>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32[])" />
		// Token: 0x06001C19 RID: 7193 RVA: 0x0008AD3C File Offset: 0x00088F3C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, uint[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__106 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__106();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__106>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32)" />
		// Token: 0x06001C1A RID: 7194 RVA: 0x0008AD90 File Offset: 0x00088F90
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, uint value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__107 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__107();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__107>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single[])" />
		// Token: 0x06001C1B RID: 7195 RVA: 0x0008ADE4 File Offset: 0x00088FE4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, float[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__108 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__108();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__108>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single)" />
		// Token: 0x06001C1C RID: 7196 RVA: 0x0008AE38 File Offset: 0x00089038
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, float value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__109 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__109();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__109>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64[])" />
		// Token: 0x06001C1D RID: 7197 RVA: 0x0008AE8C File Offset: 0x0008908C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, long[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__110 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__110();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__110>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64)" />
		// Token: 0x06001C1E RID: 7198 RVA: 0x0008AEE0 File Offset: 0x000890E0
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, long value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__111 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__111();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__111>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64[])" />
		// Token: 0x06001C1F RID: 7199 RVA: 0x0008AF34 File Offset: 0x00089134
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ulong[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__112 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__112();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__112>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64)" />
		// Token: 0x06001C20 RID: 7200 RVA: 0x0008AF88 File Offset: 0x00089188
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, ulong value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__113 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__113();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__113>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double[])" />
		// Token: 0x06001C21 RID: 7201 RVA: 0x0008AFDC File Offset: 0x000891DC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, double[] values)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__114 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__114();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__114>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double)" />
		// Token: 0x06001C22 RID: 7202 RVA: 0x0008B030 File Offset: 0x00089230
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, double value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__115 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__115();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__115>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String)" />
		// Token: 0x06001C23 RID: 7203 RVA: 0x0008B084 File Offset: 0x00089284
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__116 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__116();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__116>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001C24 RID: 7204 RVA: 0x0008B0D8 File Offset: 0x000892D8
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, Encoding encoding)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__117 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__117();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__117>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32)" />
		// Token: 0x06001C25 RID: 7205 RVA: 0x0008B134 File Offset: 0x00089334
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__118 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__118();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__118>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001C26 RID: 7206 RVA: 0x0008B190 File Offset: 0x00089390
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length, Encoding encoding)
		{
			NetworkUdpDeviceBase.<WriteAsync>d__119 <WriteAsync>d__ = new NetworkUdpDeviceBase.<WriteAsync>d__119();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkUdpDeviceBase.<WriteAsync>d__119>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		// Token: 0x04000613 RID: 1555
		private IByteTransform byteTransform;
	}
}
